package cn.jmi.jmiopenatommanagementsystem.service;

import cn.jmi.jmiopenatommanagementsystem.mapper.UserMapper;
import cn.jmi.jmiopenatommanagementsystem.pojo.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Optional;

/**
 * 用户服务层
 * 处理用户相关的业务逻辑，作为控制器和数据访问层之间的桥梁
 *
 * @Service 注解：标识该类为Spring的服务层组件，包含业务逻辑
 * @Slf4j 注解：Lombok提供的日志注解，自动生成log对象
 */
@Slf4j
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 添加用户
     * @param user 用户实体对象
     * @return 保存后的用户对象，包含生成的主键ID
     */
    @Transactional
    public User addUser(User user) {
        log.info("开始执行新增用户，用户信息：{}", user);
        try {
            User savedUser = userMapper.save(user);
            log.info("新增用户成功，用户ID：{}", savedUser.getId());
            return savedUser;
        } catch (Exception e) {
            log.error("新增用户失败，用户信息：{}，错误原因：{}", user, e.getMessage(), e);
            throw new RuntimeException("新增用户失败：" + e.getMessage());
        }
    }

    /**
     * 查询所有用户
     * @return 用户列表，如果没有用户则返回空列表
     */
    public List<User> findAllUser() {
        log.info("开始执行查找所有用户");
        try {
            List<User> users = (List<User>) userMapper.findAll();
            log.info("查找所有用户成功，共找到 {} 个用户", users.size());
            return users;
        } catch (Exception e) {
            log.error("查找所有用户失败，错误原因：{}", e.getMessage(), e);
            throw new RuntimeException("查询用户列表失败：" + e.getMessage());
        }
    }

    /**
     * 更新用户信息
     * @param user 要更新的用户对象，必须包含有效的主键ID
     * @return 更新后的用户对象
     * @throws RuntimeException 当用户不存在时抛出异常
     */
    @Transactional
    public User updateUser(User user) {
        log.info("开始执行更新用户，用户ID：{}", user.getId());

        // 检查用户是否存在
        if (!userMapper.existsById(user.getId())) {
            log.warn("更新用户失败，用户不存在，用户ID：{}", user.getId());
            throw new RuntimeException("用户不存在，无法更新");
        }

        try {
            User updatedUser = userMapper.save(user);
            log.info("更新用户成功，用户ID：{}", updatedUser.getId());
            return updatedUser;
        } catch (Exception e) {
            log.error("更新用户失败，用户ID：{}，错误原因：{}", user.getId(), e.getMessage(), e);
            throw new RuntimeException("更新用户失败：" + e.getMessage());
        }
    }

    /**
     * 删除用户
     * @param user 要删除的用户对象，必须包含有效的主键ID
     * @return 删除是否成功
     */
    @Transactional
    public boolean deleteUser(User user) {
        log.info("开始执行删除用户，用户ID：{}", user.getId());

        // 检查用户是否存在
        if (!userMapper.existsById(user.getId())) {
            log.warn("删除用户失败，用户不存在，用户ID：{}", user.getId());
            return false;
        }

        try {
            userMapper.delete(user);
            // 验证删除是否成功
            boolean deleted = !userMapper.existsById(user.getId());
            if (deleted) {
                log.info("删除用户成功，用户ID：{}", user.getId());
            } else {
                log.warn("删除用户后验证失败，用户可能仍存在，用户ID：{}", user.getId());
            }
            return deleted;
        } catch (Exception e) {
            log.error("删除用户失败，用户ID：{}，错误原因：{}", user.getId(), e.getMessage(), e);
            return false;
        }
    }

    /**
     * 根据ID查询用户
     * @param id 用户ID
     * @return 用户对象，如果不存在则返回null
     */
    public User findUserById(Long id) {
        log.info("根据ID查询用户，用户ID：{}", id);
        try {
            Optional<User> userOptional = userMapper.findById(id);
            if (userOptional.isPresent()) {
                log.info("根据ID查询用户成功，用户ID：{}", id);
                return userOptional.get();
            } else {
                log.info("用户不存在，用户ID：{}", id);
                return null;
            }
        } catch (Exception e) {
            log.error("根据ID查询用户失败，用户ID：{}，错误原因：{}", id, e.getMessage(), e);
            throw new RuntimeException("查询用户失败：" + e.getMessage());
        }
    }
}